/**
 * 目录结构
 * 1.实现类似jsp中<%=basePath%>的功能，获取项目根目录有助于url的填写
 * 2.根据台位编号查询台位名称
 * 3.获取当前网页的url
 * 4.去空格函数
 * 5.对Date的扩展，将 Date 转化为指定格式的String
 * 6.从url中获取参数
 * 7.判断obj是否为json对象
 * 8.判断obj是否是json字符串
 * 9.判断是否是整数
 * 10.定时函数(让程序休眠一段时间)
 * 11.获取json数组中某个值的下标
 * 12.利用原型重写indexOf方法,获取数组中某个值的下标
 * 13.判断字符串是否是日期时间格式
 * 14.在字符串的指定位置插入指定字符串(利用原型实现)
 * 15.任意的一个元素移动到任意的目标位置----匀速的
 * 16.变速动画函数
 * 17.得到父页面的相关属性
 * 18.将页面位置的横坐标转化为对应的实际值
 * 19.函数去抖与函数节流
 * 20.获取字符串的单位(例:12.4℃ 获取的结果为℃)
 * 21.将svg转换为canves
 */
//全局ajax处理函数
$(document)
      .ajaxStart(function () {
        // 只要有 ajax 请求发生 就会执行
        // 显示加载提示
        //console.log('注意即将要开始请求了')
      })
      .ajaxStop(function () {
        // 只要有 ajax 请求结束 就会执行
        // 结束提示
        //console.log('请求结束了')
      })



//1.实现类似jsp中<%=basePath%>的功能，获取项目根目录有助于url的填写
function getBasePath(){
    //获取当前网址，如： http://localhost:8080/ems/Pages/Basic/Person.jsp
    var curWwwPath = window.document.location.href;
    //获取主机地址之后的目录，如： /ems/Pages/Basic/Person.jsp
    var pathName = window.document.location.pathname;
    var pos = curWwwPath.indexOf(pathName);
    //获取主机地址，如： http://localhost:8080
    var localhostPath = curWwwPath.substring(0, pos);
    //获取带"/"的项目名，如：/ems
   var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);

    //获取项目的basePath   http://localhost:8080/ems/
    var basePath=localhostPath+projectName+"/";
    return basePath;
};

//2.根据台位编号查询台位名称
function getUnitNameByUnitNo(unitNo){
    let basePath=getBasePath();
    let unitName="";
    $.ajax({
        type: "get",
        async: false,//设置为同步请求,防止接收不到数据
        url: basePath+config.bxxs.apiPath+"/TestUnitConfig/getUnitNameByUnitNo",
        data:{
            unitNo:unitNo
        },
        success: function (msg) {
            unitName=msg.testunitname;
        },
        error: function (e) {
            alert("网页发生错误：", e, "error");
        }
    });
    return unitName;
}

//3.获取当前网页的url
function getCurrentPageUrl()
{
    var strUrl = location.href;
    var arrUrl = strUrl.split("/");
    var strPage = arrUrl[arrUrl.length - 1];
    return strPage;
}
//4.去空格函数
function trim(str){
    return str.replace(/\s|\xA0/g,"");
}
// 5.对Date的扩展，将 Date 转化为指定格式的String
// 月(M)、日(d)、小时(h)、分(m)、秒(s)、季度(q) 可以用 1-2 个占位符，
// 年(y)可以用 1-4 个占位符，毫秒(S)只能用 1 个占位符(是 1-3 位的数字)
// 例子：
// (new Date()).Format("yyyy-MM-dd hh:mm:ss.S") ==> 2006-07-02 08:09:04.423
// (new Date()).Format("yyyy-M-d h:m:s.S") ==> 2006-7-2 8:9:4.18
Date.prototype.Format = function (fmt) { // author: meizz
    var o = {
        "M+": this.getMonth() + 1, // 月份
        "d+": this.getDate(), // 日
        "h+": this.getHours(), // 小时
        "m+": this.getMinutes(), // 分
        "s+": this.getSeconds(), // 秒
        "q+": Math.floor((this.getMonth() + 3) / 3), // 季度
        "S": this.getMilliseconds() // 毫秒
    };
    if (/(y+)/.test(fmt))
        fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
    for (var k in o)
        if (new RegExp("(" + k + ")").test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
    return fmt;
}
//6.从url中获取参数
//使用方式:定义全局变量
//RequestUrl = getUrlRequest();
function getUrlRequest()
{
    var url = location.search; //获取url中"?"符后的字串
    var theRequest = new Object();
    if (url.indexOf("?") != -1)
    {
        var str = url.substr(1);
        if (str.indexOf("&") != -1)
        {
            strs = str.split("&");
            for (var i = 0; i < strs.length; i++)
            {
                theRequest[strs[i].split("=")[0]] = unescape(strs[i].split("=")[1]);
            }
        }
        else
        {
            var key = str.substring(0, str.indexOf("="));
            var value = str.substr(str.indexOf("=") + 1);
            theRequest[key] = decodeURI(value);
        }
    }
    return theRequest;
}

//7.判断obj是否为json对象
function isJson(obj){
    var isjson = typeof(obj) == "object" && Object.prototype.toString.call(obj).toLowerCase() == "[object object]" && !obj.length;
    return isjson;
}

//8.判断obj是否是json字符串
function isJsonStr(str) {
    if (typeof str == 'string') {
        try {
            var obj=JSON.parse(str);
            if(typeof obj == 'object' && obj ){
                return true;
            }else{
                return false;
            }

        } catch(e) {
            console.log('error：'+str+'!!!'+e);
            return false;
        }
    }
    console.log('It is not a string!')
}

//9.判断是否是整数
function isNumber(val){
    //1.判断是否是数字
    var regPos = /^\d+(\.\d+)?$/; //非负浮点数
    var regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/; //负浮点数
    if(regPos.test(val) || regNeg.test(val)){
        return true;
    }else{
        return false;
    }
}
//10.定时函数(让程序休眠一段时间)
// function sleep (time) {
//     return new Promise((resolve) => setTimeout(resolve, time));
// }

function sleep(numberMillis) {
    var now = new Date();
    var exitTime = now.getTime() + numberMillis;
    while (true) {
        now = new Date();
        if (now.getTime() > exitTime)
            return;
    }
}
//11.获取json数组中某个值的下标
function getArrayItemIndex(arr, id) {
    var index = -1;
    if (typeof Array.prototype.findIndex === 'function') {
        index = arr.findIndex(function(item) {
            return item.id === id;
        });
    }
    else {
        for (var i = 0; i < arr.length;i++) {
            if (arr[i].id === id) {
                index = i;
                break;
            }
        }
    }

    return index;
}
//12.利用原型重写indexOf方法,获取数组中某个值的下标
Array.prototype.indexOf=function(v)
{
    for(var i in this)
    {
        if(this[i]==v) return i;
    }
    return -1;
};
//13.判断字符串是否是日期时间格式,形如 (2008-09-13 23:30:06)
function isDateTime(str)
{
    var reg = /^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/;
    var r = str.match(reg);
    if(r==null)return false;
    var d= new Date(r[1], r[3]-1,r[4],r[5],r[6],r[7]);
    return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]&&d.getHours()==r[5]&&d.getMinutes()==r[6]&&d.getSeconds()==r[7]);
}
//13.判断字符串是否是日期格式,形如 (2008-09-13)
function isDate(str)
{
    var r = str.match(/^(\d{1,4})(-|\/)(\d{1,2})\2(\d{1,2})$/);
    if(r==null)return false;
    var d= new Date(r[1], r[3]-1, r[4]);
    return (d.getFullYear()==r[1]&&(d.getMonth()+1)==r[3]&&d.getDate()==r[4]);
}
//13.判断字符串是否是时间格式,形如 (23:30:06)
function isTime(str)
{
    var a = str.match(/^(\d{1,2})(:)?(\d{1,2})\2(\d{1,2})$/);
    if (a == null) {alert('输入的参数不是时间格式'); return false;}
    if (a[1]>24 || a[3]>60 || a[4]>60)
    {
        alert("时间格式不对");
        return false
    }
    return true;
}
//14.在字符串的指定位置插入指定字符串(利用原型实现)
String.prototype.splice = function(start, newStr) {
    return this.slice(0, start) + newStr + this.slice(start);
};

//15.任意的一个元素移动到任意的目标位置----匀速的
//调用示例:animate(my$("dv"),800);
function animate(element,target) {
    //清理定时器
    clearInterval(element.timeId);
    element.timeId=setInterval(function () {
        //当前位置
        var current=element.offsetLeft;
        //每次移动的步数
        var step=10;
        //移动的是正数还是负数
        step=current<target?step:-step;
        //移动后的当前位置计算
        current+=step;
        //判断是否移动
        if(Math.abs(target-current)>Math.abs(step)){
            element.style.left=current+"px";
        }else{
            //直接到达目标
            element.style.left=target+"px";
            //清理定时去
            clearInterval(element.timeId);
        }
    },20);
}

//根据id获取对应的元素
function my$(id) {
    return document.getElementById(id);
}
//获取任意一个元素的任意一个属性的当前的值---当前属性的位置值
function getStyle(element, attr) {
    return window.getComputedStyle ? window.getComputedStyle(element, null)[attr] : element.currentStyle[attr] || 0;
}
//16.变速动画函数
//调用示例
// var json1 = {"width": 400, "height": 500, "left": 500, "top": 80, "opacity": 0.2};
// shift(my$("dv"), json1);
function shift(element, json) {
    clearInterval(element.timeId);//清理定时器
    //定时器,返回的是定时器的id
    element.timeId = setInterval(function () {
        var flag = true;//默认,假设,全部到达目标
        //遍历json对象中的每个属性还有属性对应的目标值
        for (var attr in json) {
            //判断这个属性attr中是不是opacity
            if (attr == "opacity") {
                //获取元素的当前的透明度,当前的透明度放大100倍
                var current = getStyle(element, attr) * 100;
                //目标的透明度放大100倍
                var target = json[attr] * 100;
                var step = (target - current) / 10;
                step = step > 0 ? Math.ceil(step) : Math.floor(step);
                current += step;//移动后的值
                element.style[attr] = current / 100;
            } else if (attr == "zIndex") { //判断这个属性attr中是不是zIndex
                //层级改变就是直接改变这个属性的值
                element.style[attr] = json[attr];
            } else {
                //普通的属性
                //获取元素这个属性的当前的值
                var current = parseInt(getStyle(element, attr));
                //当前的属性对应的目标值
                var target = json[attr];
                //移动的步数
                var step = (target - current) / 10;
                step = step > 0 ? Math.ceil(step) : Math.floor(step);
                current += step;//移动后的值
                element.style[attr] = current + "px";
            }
            //是否到达目标
            if (current != target) {
                flag = false;
            }
        }
        if (flag) {
            //清理定时器
            clearInterval(element.timeId);
        }
        //测试代码
        console.log("目标:" + target + ",当前:" + current + ",每次的移动步数:" + step);
    }, 20);
}
//17.得到父页面的相关属性
//得到父页面的basePath
function getTopBasePath(topBasePath){

    if(topBasePath==undefined){
        topBasePath = getBasePath();
    }
    return topBasePath;
}

//18.将页面位置的横坐标转化为对应的实际值
function getRealXValue(x,x0,xMax){
    let timeLong = sessionStorage.getItem("timeLong");
    let bottomXlimit = $.cookie('bottomXlimit');
    let xAxisValues = "";
    if (bottomXlimit == undefined) {
        xAxisValues = parseInt(((x - x0) * timeLong / xMax).toFixed(0));
    } else {
        xAxisValues = parseInt(((x - x0) * timeLong / xMax).toFixed(0)) + parseInt(bottomXlimit);
    }
    return xAxisValues;
}

//19.函数去抖与函数节流
/**函数去抖**/
//测试案例:
// function resizehandler(){
//     console.log(++n);
// }
// window.onresize=debounce(resizehandler,500);

function debounce(method,delay){
    var timer=null;
    return function(){
        var context=this, args=arguments;
        clearTimeout(timer);
        timer=setTimeout(function(){
            method.apply(context,args);
        },delay);
    }
}

/**函数节流**/
//测试案例:
// function resizehandler(){
//     console.log(++n);
// }
// window.onresize=throttle(resizehandler,500);
function throttle(method,duration){
    var  begin=new Date();
    return function(){
        var context=this, args=arguments, current=new Date();
        if(current-begin>=duration){
            method.apply(context,args);
            begin=current;
        }
    }
}

//20.获取字符串的单位(例:12.4℃ 获取的结果为℃)
String.prototype.endWith=function(endStr){
    var d=this.length-endStr.length;
    return (d>=0&&this.lastIndexOf(endStr)==d)
}
function  getUnit(value){
    var unit = value.split(" ");
    /*if(trim(value).endWith("℃")){
        unit="℃";
    }else{
        unit="";
    }*/

    return unit[1];

}

//21.将svg转换为canvas(参数为包含svg的div元素)
function svgToCanvas(cutArea){
    //以下是对svg的处理
    var nodesToRecover = [];
    var nodesToRemove = [];
    //curveArea为需要截取成图片的dom的id
    //var svgElem = $("#curveArea").find('svg');
    var svgElem = cutArea.find('svg');
    svgElem.each(function (index, node) {
        var parentNode = node.parentNode;
        var svg = node.outerHTML.trim();

        var canvas = document.createElement('canvas');
        canvg(canvas, svg);
        if (node.style.position) {
            canvas.style.position += node.style.position;
            canvas.style.left += node.style.left;
            canvas.style.top += node.style.top;
        }

        nodesToRecover.push({
            parent: parentNode,
            child: node
        });
        parentNode.removeChild(node);

        nodesToRemove.push({
            parent: parentNode,
            child: canvas
        });

        parentNode.appendChild(canvas);
    });

}
